package com.com.ruanmeng.utils;

import android.content.Context;
import android.graphics.Bitmap;
import android.graphics.BitmapFactory;
import android.graphics.BitmapFactory.Options;
import android.graphics.Matrix;
import android.media.ExifInterface;
import android.os.Environment;
import android.widget.ImageView;

import java.io.ByteArrayInputStream;
import java.io.ByteArrayOutputStream;
import java.io.File;
import java.io.IOException;

public class BitmapHelper {

    //dip2
    public static int dip2px(Context context, double d) {
        final float scale = context.getResources().getDisplayMetrics().density;
        return (int) (d * scale + 0.5f);
    }

    //bu'me= ��������ֵתdip
    public static int px2dip(Context context, float pxValue) {
        final float scale = context.getResources().getDisplayMetrics().density;
        return (int) (pxValue / scale + 0.5f);
    }

    /***
     * ͼƬ�����ŷ���
     *
     * @param bgimage   ��ԴͼƬ��Դ
     * @param newWidth  �����ź���
     * @param newHeight �����ź�߶�
     * @return
     */
    public static Bitmap zoomImage(Bitmap bgimage, double newWidth,
                                   double newHeight) {
        // ��ȡ���ͼƬ�Ŀ�͸�
        float width = bgimage.getWidth();
        float height = bgimage.getHeight();
        // ��������ͼƬ�õ�matrix����
        Matrix matrix = new Matrix();
        // ������������
        float scaleWidth = ((float) newWidth) / width;
        float scaleHeight = ((float) newHeight) / height;
        // ����ͼƬ����
        matrix.postScale(scaleWidth, scaleHeight);
        Bitmap bitmap = Bitmap.createBitmap(bgimage, 0, 0, (int) width,
                (int) height, matrix, true);
        return bitmap;
    }

    public static void setImgFromSD(ImageView iv, int width) {
        File file = new File(Environment.getExternalStorageDirectory() + "/photo_jq.jpg");
        if (file.exists()) {
            Options opts = new Options();
            opts.inJustDecodeBounds = true;
            BitmapFactory.decodeFile(file.getAbsolutePath(), opts);
            opts.inSampleSize = opts.outWidth / width;
            opts.inJustDecodeBounds = false;
            Bitmap bm = BitmapFactory.decodeFile(file.getAbsolutePath(), opts);
            iv.setImageBitmap(bm);
        }
    }

    /**
     * ����ͼƬ��Сѹ��ͼƬ
     *
     * @param pathString ͼƬ����·��
     * @return Bitmapѹ����ͼƬ
     */
    @SuppressWarnings("deprecation")
    public static Bitmap getDiskBitmap(String pathString) {
        Bitmap bitmap = null;
        Bitmap bMapRotate = null;
        try {
            File file = new File(pathString);
            if (file.exists()) {
                Options opt = new Options();
                opt.inPreferredConfig = Bitmap.Config.RGB_565;
                opt.inPurgeable = true;
                opt.inInputShareable = true;
                opt.inTempStorage = new byte[1024 * 1024 * 10];
                long length = file.length();
                if (length / (1024 * 1024) > 4) {
                    opt.inSampleSize = 16;
                } else if (length / (1024 * 1024) >= 1) {
                    opt.inSampleSize = 8;
                } else if (length / (1024 * 512) >= 1) {
                    opt.inSampleSize = 4;
                } else if (length / (1024 * 256) >= 1) {
                    opt.inSampleSize = 2;
                } else {
                    opt.inSampleSize = 1;
                }
                bitmap = BitmapFactory.decodeFile(pathString, opt);
                int orientation = getDegress(pathString);
                /*
				 * if(bitmap.getHeight() < bitmap.getWidth()){ orientation = 90;
				 * } else { orientation = 0; }
				 */
                if (orientation != 0) {
                    Matrix matrix = new Matrix();
                    matrix.postRotate(orientation);
                    bMapRotate = Bitmap
                            .createBitmap(bitmap, 0, 0, bitmap.getWidth(),
                                    bitmap.getHeight(), matrix, true);
                } else {
                    bMapRotate = Bitmap.createScaledBitmap(bitmap,
                            bitmap.getWidth(), bitmap.getHeight(), true);
                }
            }
        } catch (Exception e) {
            e.printStackTrace();
        }
        if (bMapRotate != null) {
            return bMapRotate;
        }
        return bitmap;
    }


    /**
     * ��ȡͼƬ���ԣ���ת�ĽǶ�
     *
     * @param path ͼƬ����·��
     * @return degree��ת�ĽǶ�
     */
    public static int getDegress(String path) {
        int degree = 0;
        try {
            ExifInterface exifInterface = new ExifInterface(path);
            int orientation = exifInterface.getAttributeInt(
                    ExifInterface.TAG_ORIENTATION,
                    ExifInterface.ORIENTATION_NORMAL);
            switch (orientation) {
                case ExifInterface.ORIENTATION_ROTATE_90:
                    degree = 90;
                    break;
                case ExifInterface.ORIENTATION_ROTATE_180:
                    degree = 180;
                    break;
                case ExifInterface.ORIENTATION_ROTATE_270:
                    degree = 270;
                    break;
            }
        } catch (IOException e) {
            e.printStackTrace();
        }
        return degree;
    }

    /**
     * ��תͼƬ
     *
     * @param bitmap
     * @param degress
     * @return
     */
    public static Bitmap rotateBitmap(Bitmap bitmap, int degress) {
        if (bitmap != null) {
            Matrix m = new Matrix();
            m.postRotate(degress);
            bitmap = Bitmap.createBitmap(bitmap, 0, 0, bitmap.getWidth(), bitmap.getHeight(), m, true);
            return bitmap;
        }
        return bitmap;
    }

    /**
     * ����ѹ������(���ͼƬ����ָ���Ĵ�С��ѭ��ѹ��)
     *
     * @param image
     * @param maxkb
     * @return Bitmap    ��������
     */
    public static Bitmap compressImage(Bitmap image, int maxkb) {
        ByteArrayOutputStream baos = new ByteArrayOutputStream();
        //����ѹ������������100��ʾ��ѹ������ѹ��������ݴ�ŵ�baos��
        image.compress(Bitmap.CompressFormat.JPEG, 100, baos);
        int options = 100;
        //ѭ���ж����ѹ����ͼƬ�Ƿ����100kb,���ڼ���ѹ��
        while (baos.toByteArray().length / 1024 > maxkb) {
            //����baos�����baos
            baos.reset();
            //ÿ�ζ�����10
            options -= 10;
            image.compress(Bitmap.CompressFormat.JPEG, options, baos);
        }
        if (image != null) image.recycle();
        ByteArrayInputStream isBm = new ByteArrayInputStream(baos.toByteArray());
        Bitmap bitmap = BitmapFactory.decodeStream(isBm, null, null);
        return bitmap;
    }

    /**
     * ͼƬ��������Сѹ������������·����ȡͼƬ��ѹ����
     *
     * @param @param  srcPath
     * @param @return ����
     * @return Bitmap    ��������
     */
    public static Bitmap getImage(String srcPath) {
        Options newOpts = new Options();
        //��ʼ����ͼƬ����ʱ��options.inJustDecodeBounds ���true��
        newOpts.inJustDecodeBounds = true;
        Bitmap bitmap = BitmapFactory.decodeFile(srcPath, newOpts);//��ʱ����bmΪ��

        newOpts.inJustDecodeBounds = false;
        int w = newOpts.outWidth;
        int h = newOpts.outHeight;
        //���������ֻ��Ƚ϶���800*480�ֱ��ʣ����ԸߺͿ���������Ϊ
        float hh = 800f;//�������ø߶�Ϊ800f
        float ww = 480f;//�������ÿ��Ϊ480f
        //���űȡ������ǹ̶��������ţ�ֻ�ø߻��߿�����һ�����ݽ��м��㼴��
        int be = 1;//be=1��ʾ������
        if (w > h && w > ww) {//�����ȴ�Ļ����ݿ�ȹ̶���С����
            be = (int) (newOpts.outWidth / ww);
        } else if (w < h && h > hh) {//����߶ȸߵĻ����ݿ�ȹ̶���С����
            be = (int) (newOpts.outHeight / hh);
        }
        if (be <= 0)
            be = 1;
        newOpts.inSampleSize = be;//�������ű���
        //���¶���ͼƬ��ע���ʱ�Ѿ���options.inJustDecodeBounds ���false��
        bitmap = BitmapFactory.decodeFile(srcPath, newOpts);
        return compressImage(bitmap, 100);//ѹ���ñ�����С���ٽ�������ѹ��
    }

    /**
     * ͼƬ��������Сѹ������������·����ȡͼƬ��ѹ����
     *
     * @param @param  srcPath
     * @param @param  maxkb   һ������Ϊ100kb
     * @param @return ����
     * @return Bitmap    ��������
     */
    public static Bitmap getImage(String srcPath, int maxkb) {
        Options newOpts = new Options();
        //��ʼ����ͼƬ����ʱ��options.inJustDecodeBounds ���true��
        newOpts.inJustDecodeBounds = true;
        Bitmap bitmap = BitmapFactory.decodeFile(srcPath, newOpts);//��ʱ����bmΪ��

        newOpts.inJustDecodeBounds = false;
        int w = newOpts.outWidth;
        int h = newOpts.outHeight;
        //���������ֻ��Ƚ϶���800*480�ֱ��ʣ����ԸߺͿ���������Ϊ
        float hh = 800f;//�������ø߶�Ϊ800f
        float ww = 480f;//�������ÿ��Ϊ480f
        //���űȡ������ǹ̶��������ţ�ֻ�ø߻��߿�����һ�����ݽ��м��㼴��
        int be = 1;//be=1��ʾ������
        if (w > h && w > ww) {//�����ȴ�Ļ����ݿ�ȹ̶���С����
            be = (int) (newOpts.outWidth / ww);
        } else if (w < h && h > hh) {//����߶ȸߵĻ����ݿ�ȹ̶���С����
            be = (int) (newOpts.outHeight / hh);
        }
        if (be <= 0)
            be = 1;
        newOpts.inSampleSize = be;//�������ű���
        //���¶���ͼƬ��ע���ʱ�Ѿ���options.inJustDecodeBounds ���false��
        bitmap = BitmapFactory.decodeFile(srcPath, newOpts);
        return compressImage(bitmap, maxkb); //ѹ���ñ�����С���ٽ�������ѹ��
    }

    /**
     * ͼƬ��������Сѹ������������BitmapͼƬѹ����
     *
     * @param @param  image
     * @param @return ����
     * @return Bitmap    ��������
     */
    public static Bitmap compressImage(Bitmap image) {
        ByteArrayOutputStream baos = new ByteArrayOutputStream();
        image.compress(Bitmap.CompressFormat.JPEG, 100, baos);
        // �ж����ͼƬ����1M,����ѹ������������ͼƬ��BitmapFactory.decodeStream��ʱ���
        if (baos.toByteArray().length / 1024 > 1024) {
            // ����baos�����baos
            baos.reset();
            // ����ѹ��50%����ѹ��������ݴ�ŵ�baos��
            image.compress(Bitmap.CompressFormat.JPEG, 50, baos);
        }
        if (image != null) image.recycle();
        ByteArrayInputStream isBm = new ByteArrayInputStream(baos.toByteArray());
        Options newOpts = new Options();
        //��ʼ����ͼƬ����ʱ��options.inJustDecodeBounds ���true��
        newOpts.inJustDecodeBounds = true;
        Bitmap bitmap = BitmapFactory.decodeStream(isBm, null, newOpts);
        newOpts.inJustDecodeBounds = false;
        int w = newOpts.outWidth;
        int h = newOpts.outHeight;
        //���������ֻ��Ƚ϶���800*480�ֱ��ʣ����ԸߺͿ���������Ϊ
        float hh = 800f;//�������ø߶�Ϊ800f
        float ww = 480f;//�������ÿ��Ϊ480f
        //���űȡ������ǹ̶��������ţ�ֻ�ø߻��߿�����һ�����ݽ��м��㼴��
        int be = 1;//be=1��ʾ������
        if (w > h && w > ww) {//�����ȴ�Ļ����ݿ�ȹ̶���С����
            be = (int) (newOpts.outWidth / ww);
        } else if (w < h && h > hh) {//����߶ȸߵĻ����ݿ�ȹ̶���С����
            be = (int) (newOpts.outHeight / hh);
        }
        if (be <= 0)
            be = 1;
        newOpts.inSampleSize = be;//�������ű���
        //���¶���ͼƬ��ע���ʱ�Ѿ���options.inJustDecodeBounds ���false��
        isBm = new ByteArrayInputStream(baos.toByteArray());
        bitmap = BitmapFactory.decodeStream(isBm, null, newOpts);
        return compressImage(bitmap, 100);//ѹ���ñ�����С���ٽ�������ѹ��
    }

    /**
     * ��byte[] ת�� Bitmap
     */
    public static Bitmap Bytes2Bimap(byte[] b) {
        if (b.length != 0) {
            return BitmapFactory.decodeByteArray(b, 0, b.length);
        } else {
            return null;
        }
    }

    /**
     * ��Bitmapת�� byte[]
     */
    public byte[] Bitmap2Bytes(Bitmap bm) {
        ByteArrayOutputStream baos = new ByteArrayOutputStream();
        bm.compress(Bitmap.CompressFormat.PNG, 100, baos);
        return baos.toByteArray();
    }
}
